Advanced Shell Scripting

Shell scripting is a powerful tool for automating tasks and managing Unix systems. This tutorial will explore advanced techniques in shell scripting, including control structures, functions, error handling, and interacting with system processes.

Introduction to Shell Scripting

Shell scripts are text files containing a sequence of commands that are executed by the shell. They are used to automate repetitive tasks, manage system configurations, and perform complex operations. Advanced shell scripting requires a deep understanding of shell syntax, control structures, and system commands.

Control Structures

Control structures allow you to control the flow of execution in a shell script. Here are some common control structures:

If-Else Statements

If-else statements are used to execute commands based on a condition:


if [ condition ]; then
    # Commands to execute if condition is true
elif [ another_condition ]; then
    # Commands to execute if another_condition is true
else
    # Commands to execute if all conditions are false
fi

Case Statements

Case statements are used to execute commands based on multiple conditions:


case $variable in
    pattern1)
        # Commands to execute if variable matches pattern1
        ;;
    pattern2)
        # Commands to execute if variable matches pattern2
        ;;
    *)
        # Commands to execute if variable does not match any pattern
        ;;
esac

For Loops

For loops are used to iterate over a list of items:


for item in list; do
    # Commands to execute for each item
done

While Loops

While loops are used to execute commands as long as a condition is true:


while [ condition ]; do
    # Commands to execute while condition is true
done

Until Loops

Until loops are used to execute commands until a condition becomes true:


until [ condition ]; do
    # Commands to execute until condition becomes true
done

Functions

Functions allow you to group commands into reusable blocks. Here is the syntax for defining and calling functions:

Defining Functions


function_name() {
    # Commands to execute
}

Calling Functions


function_name

Passing Arguments to Functions

Arguments can be passed to functions and accessed using positional parameters:


function_name() {
    arg1=$1
    arg2=$2
    # Commands to execute using arg1 and arg2
}

function_name value1 value2

Error Handling

Error handling is essential for creating robust shell scripts. Here are some techniques for error handling:

Exit Status

Every command returns an exit status, which can be checked to determine if the command was successful:


command
if [ $? -eq 0 ]; then
    echo "Command succeeded"
else
    echo "Command failed"
fi

Using set -e

The set -e command causes the script to exit immediately if any command returns a non-zero exit status:


set -e
command1
command2

Trap Command

The trap command allows you to specify commands to execute when the script exits or receives a signal:


trap 'echo "An error occurred. Exiting..."; exit 1' ERR
command1
command2

Interacting with System Processes

Shell scripts can interact with system processes to perform various tasks. Here are some common techniques:

Background Processes

Commands can be run in the background by appending an ampersand (&) to the command:


command &

Waiting for Processes

The wait command waits for background processes to complete:


command1 &
command2 &
wait

Process Substitution

Process substitution allows you to use the output of a command as input to another command:


diff <(command1) <(command2)

Reading from Pipes

Pipes allow you to pass the output of one command as input to another command:


command1 | command2

Example: Backup Script

Let's create a backup script that compresses a directory and stores the backup in a specified location. The script will include error handling and logging:

Backup Script


#!/bin/bash

# Function to display usage information
usage() {
    echo "Usage: $0 source_directory backup_directory"
    exit 1
}

# Check if the correct number of arguments is provided
if [ $# -ne 2 ]; then
    usage
fi

SOURCE_DIR=$1
BACKUP_DIR=$2
TIMESTAMP=$(date +%Y%m%d%H%M%S)
BACKUP_FILE="$BACKUP_DIR/backup_$TIMESTAMP.tar.gz"
LOG_FILE="$BACKUP_DIR/backup_$TIMESTAMP.log"

# Function to log messages
log() {
    echo "$(date +%Y-%m-%d\ %H:%M:%S) - $1" | tee -a $LOG_FILE
}

# Error handling
trap 'log "An error occurred. Exiting..."; exit 1' ERR
set -e

# Create backup
log "Starting backup of $SOURCE_DIR to $BACKUP_FILE"
tar -czf $BACKUP_FILE $SOURCE_DIR
log "Backup completed successfully"

exit 0

Practice Exercises

Here are some practice exercises to help you develop your shell scripting skills:

  1. Write a script to monitor disk usage and send an email alert if usage exceeds a specified threshold.
  2. Write a script to automate the process of updating and upgrading system packages.
  3. Write a script to search for files with specific extensions in a directory and move them to a specified location.
  4. Write a script to generate a report of system resource usage (CPU, memory, disk) and save it to a file.
  5. Write a script to create user accounts from a CSV file and set default passwords.

 

 

Check out some other Bands on Bandcamp.com. Crazy Fingers (Vancouver 1991), Flying Butt Pliers, and Hammy Ham Hands.

Proudly powered by a Text Editor, an IDE, an SFTP client, some Internet searches, and more recently help from some AI.

2025 dispelled.ca end of file.